const db = wx.cloud.database()
Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 当前导航栏
    tabNow: 0,
    tabList: ["全部", "我的订单", "正在悬赏", "我帮助的"],
    // 用户的openId
    openId: '',
    // 所有订单列表
    orderList: [],
    // 我的订单
    myOrder: [],
    // 我帮助的订单
    helpOrder: [],
    // 正在悬赏的订单
    rewardOrder: [],
    // 判断是否是接单员
    isTakeOrder: false,
    // 已完成单数
    totalNum: 0,
    // 总收益
    totalMoney: 0,
  },

  // 跳转页面
  jumpPage(e) {
    const index = e.target.dataset.index
    // 修改当前页面的索引
    this.setData({
      tabNow: index
    })
    // 加载不同的数据
    switch (index) {
      case 0:
        // 获取"全部订单"信息
        this.getAllOrder()
        break;
      case 1:
        // 获取"我的订单"信息
        this.getMyOrder()
        break;
      case 2:
        // 获取" 正在悬赏的订单"信息
        this.getRewardOrder()
        break;
      case 3:
        // 获取"我帮助的订单"信息
        this.getHelpOrder()
        break;
    }
  },

  // 点击接单按钮
  takeOrders(e) {
    // 如果不是接单员，提示用户并不继续执行代码
    if (!this.data.isTakeOrder) {
      wx.showModal({
        title: '提示',
        content: '您目前不是接单员，请前往个人中心申请称为接单员！',
        showCancel: false
      })
      return
    }
    wx.showLoading({
      title: '加载中...',
    })
    // 获取当前点击的订单信息
    const {
      item
    } = e.target.dataset
    // 每条订单都有唯一的"_id"
    const {
      _id,
      _openid
    } = item
    // 如果接单员是自己，也是无法接单的
    // if (_openid === this.data.openId) {
    //   wx.showToast({
    //     title: '无法接自己的单',
    //     icon:'none'
    //   })
    //   return
    // }
    // 更新订单状态
    db.collection('order').doc(_id).update({
      data: {
        // 修改订单状态
        state: '已帮助',
        // 设置接单员
        receiver: this.data.openId
      },
      success: (res) => {
        if (this.data.tabNow === 0) {
          this.getAllOrder()
        } else {
          this.getRewardOrder()
        }
        wx.hideLoading()
      }
    })
  },

  // 点击已完成按钮
  async finish(e) {
    wx.showLoading({
      title: '加载中...',
    })
    const {
      _id: orderId,
      money,
      receive
    } = e.target.dataset.item
    // 获取该订单的接单员的相关信息
    const res = await db.collection('applyOrderInfo').where({
      _openid: receive
    }).get()
    const item = res.data[0]
    // 获取总金额和接单数以及帮助列表
    let {
      totalNum,
      totalMoney,
      _id,
      helpedOrder
    } = item
    totalNum++
    totalMoney += money
    helpedOrder.push(e.target.dataset.item)
    // 调用云函数更新数据
    await wx.cloud.callFunction({
      name: 'updataReceiver',
      data: {
        _id,
        totalMoney,
        totalNum,
        helpedOrder
      }
    })
    // 更新订单状态
    db.collection('order').doc(orderId).update({
      data: {
        state: '已完成',
      },
      success: (res) => {
        this.getMyOrder()
        wx.hideLoading()
      }
    })
  },

  // 获取"全部订单的信息"
  getAllOrder() {
    // 限制每次返回5条数据
    db.collection("order").orderBy('timeStamp', "desc").limit(5).get({
      success: (res) => {
        const {
          data
        } = res
        data.forEach(item => {
          if (item.name === "打印服务") {
            item.uploadFile = item.orderInfo.uploadFile
          }
          // 格式化每个订单信息
          item.orderInfo = this.formatOrderInfo(item)
          // 设置不同状态下的样式类
          item.stateClass = this.setStateClass(item.state)
        })
        this.setData({
          orderList: data
        })
        // 停止刷新
        wx.stopPullDownRefresh()
      }
    })
  },

  // 获取"我的订单"信息
  getMyOrder() {
    db.collection("order").orderBy('timeStamp', "desc").limit(5).where({
      _openid: this.data.openId
    }).get({
      success: (res) => {
        const {
          data
        } = res
        data.forEach(item => {
          // 格式化每个订单信息
          item.orderInfo = this.formatOrderInfo(item)
          // 设置不同状态下的样式类
          item.stateClass = this.setStateClass(item.state)
        })
        this.setData({
          myOrder: data
        })
      }
    })
  },

  // 获取"我帮助的订单"信息
  getHelpOrder() {
    db.collection("applyOrderInfo").limit(5).where({
      _openid: this.data.openId
    }).get({
      success: (res) => {
        const {
          totalMoney,
          totalNum,
          helpedOrder
        } = res.data[0]
        helpedOrder.forEach(item => {
          // 修改订单状态
          item.state = "已完成"
          // 设置不同状态下的样式类
          item.stateClass = this.setStateClass(item.state)
        })
        // 更新已完成单数和总收益,以及帮助的列表
        this.setData({
          totalMoney,
          totalNum,
          helpOrder: helpedOrder
        })
      }
    })
    // db.collection("order").orderBy('timeStamp', "desc").limit(5).where({
    //   receiver: this.data.openId,
    //   state:'已完成'
    // }).get({
    //   success: (res) => {
    //     const {
    //       data
    //     } = res
    //     data.forEach(item => {
    //       // 格式化每个订单信息
    //       item.orderInfo = this.formatOrderInfo(item)
    //       // 设置不同状态下的样式类
    //       item.stateClass = this.setStateClass(item.state)
    //     })
    //     this.setData({
    //       helpOrder: data
    //     })
    //   }
    // })
  },

  // 获取"正在悬赏的订单"
  getRewardOrder() {
    db.collection("order").orderBy('timeStamp', "desc").limit(5).where({
      state: '待帮助'
    }).get({
      success: (res) => {
        const {
          data
        } = res
        data.forEach(item => {
          // 格式化每个订单信息
          item.orderInfo = this.formatOrderInfo(item)
          // 设置不同状态下的样式类
          item.stateClass = this.setStateClass(item.state)
        })
        this.setData({
          rewardOrder: data
        })
      }
    })
  },

  // 格式化订单信息
  formatOrderInfo(item) {
    switch (item.name) {
      case "快递代取": {
        const {
          size,
          business,
          remark,
          expectTime,
          expectGender,
          count
        } = item.orderInfo
        return `快递类型：${size} -- 快递数量：${count} -- 快递商家：${business} -- 期望送达：${expectTime} -- 性别限制：${expectGender} -- 备注：${remark || "无"}`
      }
      case "打印服务": {
        const {
          // 备注信息 
          remark,
          // 页数
          pagination,
          // 是否彩印
          colorPrint,
          // 是否双面
          doubleSided
        } = item.orderInfo
        return `页数：${pagination} -- 是否彩印：${colorPrint?"是":"否"} -- 是否双面：${doubleSided?"是":"否"} -- 备注：${remark}`
      }
      case "校园跑腿": {
        const {
          // 帮助内容
          helpMsg,
        } = item.orderInfo
        return `${helpMsg}`
      }
      case "快递代寄": {
        const {
          helpMsg,
          remark,
          business,
        } = item.orderInfo
        return `帮助内容：${helpMsg} -- 快递商家：${business}  -- 备注：${remark}`
      }
      case "租借服务": {
        const {
          returnTime,
          borrowMsg,
        } = item.orderInfo
        return `租借物品：${borrowMsg} -- 归还时间：${returnTime}`
      }
      case "游戏陪玩": {
        const {
          game,
          gameTime,
          remark,
          gameId,
        } = item.orderInfo
        return `游戏名称：${game} -- 游戏时间：${gameTime} -- 备注：${remark}`
      }
      case "帮我送": {
        const {
          pickUpAdderss,
          sendObject,
        } = item.orderInfo
        return `送达物品：${sendObject} -- 取货地址：${pickUpAdderss}`
      }
      case "代替服务": {
        const {
          helpMsg,
          place,
        } = item.orderInfo
        return `帮助内容：${helpMsg} -- 地址：${place}`
      }
      case "其他帮助": {
        const {
          helpMsg,
          place,
        } = item.orderInfo
        return `帮助内容：${helpMsg} -- 地址：${place}`
      }
    }
  },

  // 设置不同状态下的类
  setStateClass(state) {
    if (state === "待帮助") {
      return "waiting-help"
    } else if (state === "已帮助") {
      return "helping"
    } else {
      return "complete"
    }
  },

  // 获取当前用户的权限
  getUserPower() {
    db.collection('applyOrderInfo').where({
      _openid: this.data.openId,
      state: '通过'
    }).get({
      success: (res) => {
        // 如果能找到这样一条数据，则说明已经是接单员了
        if (res.data.length) {
          this.setData({
            isTakeOrder: true
          })
        }
      }
    })
  },

  // 删除订单（只有我的订单才显示）
  deleteOrder(e) {
    wx.showLoading({
      title: '处理中...',
    })
    const {
      id
    } = e.currentTarget.dataset
    db.collection('order').doc(id).remove({
      success: (res) => {
        wx.showToast({
          title: '删除成功',
          icon: "success",
        })
        // 更新数据
        this.getMyOrder()
        wx.hideLoading()
      }
    })
  },

  // 查看取件码截图
  seeCodeImg(e) {
    const {
      item: {
        state,
        receiver,
        screenshot
      }
    } = e.currentTarget.dataset
    wx.previewImage({
      urls: [screenshot],
    })
  },

  // 下载文件
  downLoadFile(e) {
    const {
      item: {
        uploadFile,state,receiver
      }
    } = e.currentTarget.dataset;
    // 已完成接单或者不是接该单的人无权查看
    if (state === "已完成" || receiver !== this.data.openId) {
      wx.showToast({
        title: '抱歉，您无权查看！',
        icon: 'none'
      })
      return
    }
    wx.showLoading({
      title: '加载中...',
    })
    // 从云存储空间下载文件
    wx.cloud.downloadFile({
      fileID:uploadFile,
      success:(res)=>{
        const fileManager = wx.getFileSystemManager()
        // 保存文件
        fileManager.saveFile({
          tempFilePath:res.tempFilePath,
          success:(res)=>{
            wx.hideLoading()
            wx.showToast({
              title: '下载完毕！',
            })
            // 新开页面打开文档
            wx.openDocument({
              filePath: res.savedFilePath,
              showMenu:true
            })
          }
        })
      },
      fail:(err)=>{
        console.log("出错了");
      }
    })
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 获取用户的openId
    const openId = wx.getStorageSync('openId')
    this.setData({
      openId,
    })
    this.getAllOrder()
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {},

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 获取当前用户权限
    this.getUserPower()
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {},

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    if (this.data.tabNow === 0) {
      this.getAllOrder()
    } else {
      // 停止刷新
      wx.stopPullDownRefresh()
    }
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    let {
      tabNow,
      orderList,
      myOrder,
      helpOrder,
      rewardOrder
    } = this.data
    switch (tabNow) {
      case 0:
        db.collection('order').orderBy('timeStamp', "desc").skip(orderList.length).get({
          success: (res) => {
            // 如果没有数据返回
            if (!res.data.length) {
              wx.showToast({
                title: '数据已经到底了~~',
                icon: 'error'
              })
              return
            }
            const {
              data
            } = res
            data.forEach(item => {
              // 格式化每个订单信息
              item.orderInfo = this.formatOrderInfo(item)
              // 设置不同状态下的样式类
              item.stateClass = this.setStateClass(item.state)
            })
            // 将新的数据放到旧数据的后面
            orderList = [...orderList, ...data]
            this.setData({
              orderList
            })
          },
        })
        break;
      case 1:
        db.collection('order').orderBy('timeStamp', "desc").skip(myOrder.length).where({
          _openid: this.data.openId
        }).get({
          success: (res) => {
            // 如果没有数据返回
            if (!res.data.length) {
              wx.showToast({
                title: '数据已经到底了~~',
                icon: 'error'
              })
              return
            }
            const {
              data
            } = res
            data.forEach(item => {
              // 格式化每个订单信息
              item.orderInfo = this.formatOrderInfo(item)
              // 设置不同状态下的样式类
              item.stateClass = this.setStateClass(item.state)
            })
            // 将新的数据放到旧数据的后面
            myOrder = [...myOrder, ...data]
            this.setData({
              myOrder
            })
            // 停止刷新
            wx.stopPullDownRefresh()
          }
        })
        break;
      case 2:
        db.collection('order').orderBy('timeStamp', "desc").skip(helpOrder.length).where({
          receiver: this.data.openId
        }).get({
          success: (res) => {
            // 如果没有数据返回
            if (!res.data.length) {
              wx.showToast({
                title: '数据已经到底了~~',
                icon: 'error'
              })
              return
            }
            const {
              data
            } = res
            data.forEach(item => {
              // 格式化每个订单信息
              item.orderInfo = this.formatOrderInfo(item)
              // 设置不同状态下的样式类
              item.stateClass = this.setStateClass(item.state)
            })
            // 将新的数据放到旧数据的后面
            helpOrder = [...helpOrder, ...data]
            this.setData({
              helpOrder
            })
            // 停止刷新
            wx.stopPullDownRefresh()
          }
        })
        break;
      case 3:
        db.collection('order').orderBy('timeStamp', "desc").skip(rewardOrder.length).where({
          state: '待帮助'
        }).get({
          success: (res) => {
            // 如果没有数据返回
            if (!res.data.length) {
              wx.showToast({
                title: '数据已经到底了~~',
                icon: 'error'
              })
              return
            }
            const {
              data
            } = res
            data.forEach(item => {
              // 格式化每个订单信息
              item.orderInfo = this.formatOrderInfo(item)
              // 设置不同状态下的样式类
              item.stateClass = this.setStateClass(item.state)
            })
            // 将新的数据放到旧数据的后面
            rewardOrder = [...rewardOrder, ...data]
            this.setData({
              rewardOrder
            })
            // 停止刷新
            wx.stopPullDownRefresh()
          }
        })
        break;
    }

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})